home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / rcvru.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  6KB  |  199 lines
  1.  /*
  2.  
  3.              RECEIVE RU from APPL
  4.                    r c v r u
  5.  
  6.   This subroutine receives RUs from APPL module as part of the input segment
  7.   and then places them into the input queue for the  defined RCB.
  8.  
  9.   Input  : pointer to the RCB, pointer to the segment.
  10.   Output : fill input queue for the supplied RCB.
  11.  
  12.  
  13.   CopyRight 1995. Nicholas Poljakov all rights reserved.
  14.  
  15. */
  16.  
  17. #include <stdio.h>
  18. #include <include.h>
  19. #include <rcb.h>
  20. #include <prefix.h>
  21. #include <string.h>
  22. #include <malloc.h>
  23. #include <state1.h>
  24.  
  25. #define RH_SIZE 3
  26. #define RQB_RH 19
  27. #define PR_SIZE 31
  28.  
  29. char *buff;
  30. int sk_r_wt(void *);
  31. int SendBlock(void *, void *);
  32. int setrc(void *, void *);
  33. int sendhsf(void *);
  34. int sendhs(void *);
  35. int sendbm(void *, void *);
  36. int sendat(void *);
  37. int rtsend(void *);
  38. unsigned long rmfmh5(void *, void *);
  39. int rcvhs(void *, void *, void *, void *);
  40. int ralloc(void *, void *);
  41. int psrm(int, void *, void *);
  42. int ps_conv(int, void *);
  43. int proterr(void *, unsigned long);
  44. int preptrcv(void *, void *);
  45. int post_rcb(void *);
  46. struct repass *postopen(void *);
  47. int phsrec(void *);
  48. int pfmh5(void *);
  49. int opndst(void *);
  50. int obtsess(void *, unsigned char);
  51. int Lrf_handler(void *);
  52. int get_sess(void *, void *);
  53. int get_attr(void *);
  54. int fsm_error(unsigned char, void *);
  55. int fsm_conv(unsigned char, unsigned char, void *);
  56. int flush (void *);
  57. int dcp(void *);
  58. int dealloc(void *);
  59. int crtp(void *);
  60. int conv(void *);
  61. int chkparm(void *, void *);
  62. int check_end(unsigned int, void *);
  63. struct rqb *call_appl(void *);
  64. int buffmng(unsigned char, void *, void *, void *, unsigned, unsigned char, unsigned);
  65. unsigned long attltck(void *);
  66. unsigned long attacheck(void *);
  67. char *cgetmem(int, int);
  68. int sendhsf(void *);
  69. int opndst(void *);
  70. int alloc_rcb(void *, void *);
  71. int allocate(void *);
  72. int clsdst(void *);
  73. int bldfmh7(struct rcb *, unsigned long);
  74.  
  75. int main_fd;
  76.  
  77. rcvru(p_rcb, s_ptr)
  78. struct rcb *p_rcb;
  79. struct segprf *s_ptr;
  80. {
  81.     struct rqb *p_rqb;
  82.     struct segprf *t_seg;
  83.     int i;
  84.     int ti;
  85.     int cnt;
  86.     char *p;
  87.     char *p1;
  88.     unsigned char dsc;
  89.     unsigned int type;
  90.     unsigned long sense;
  91.     unsigned char tp;
  92.     char *tp1;
  93.     union prll {
  94.                   struct chs {
  95.                                 unsigned char s1;
  96.                                 unsigned char s2;
  97.                   } chs;
  98.                   unsigned int len;
  99.                 } *pr_ll;
  100.  
  101. #if OS_TYPE == 1 /* Unix V */
  102. /*********  Trace facility **********/
  103. unsigned int rtype;   /* type of record */
  104. unsigned int pnum;    /* point number */
  105. char pname[8];        /* name of module */
  106. char *drec;       /* record for dump */
  107. int  lenr;            /* record length */
  108.  
  109. rtype = INPROC;
  110. strcpy(pname, "rcvru");
  111. pnum = 1;
  112. drec = p_rcb;
  113. lenr = sizeof(struct rcb);
  114. gtf(rtype, pname, pnum, drec, lenr);
  115. /***********************************/
  116. #endif
  117.  
  118.     cnt = 0; /* first segment */
  119.     t_seg = s_ptr;
  120.     p_rqb = (char *)t_seg + PR_SIZE - RQB_RH; /* pointer to RQB */
  121.  
  122.     /* Read all elements of the seg. chain and
  123.      * place it into an input queue to the RCB
  124.      */
  125.     do {
  126.         if (cnt != 0) {
  127. #if OS_TYPE == 1 /* Unix V */
  128.             if ((i = read(main_fd, buff, MAX_SEG)) == -1) {
  129.                 return (0); /* error in reading */
  130.             }
  131.             t_seg = buff;
  132. #endif
  133. #if OS_TYPE == 0 /* MS-DOS */
  134.             t_seg = t_seg -> link;
  135.             i = t_seg -> len - 3; /* without RH */
  136. #endif
  137. #if OS_TYPE == 1 /* Unix V */
  138. /******** Trace  ******************/
  139. rtype = GREC;
  140. strcpy(pname, "rcvru");
  141. pnum = 2;
  142. drec = buff;
  143. lenr = i;
  144. gtf(rtype, pname, pnum, drec, lenr);
  145. /***********************************/
  146. #endif
  147.  
  148.         }
  149.         else { /* cnt == 0*/
  150.             /* First segment */
  151.             i = t_seg -> len - 3;  /* RH length */
  152.             p1 = (char *)p_rqb + 16; /*sizeof(struct rqb)*/
  153.             type = *p1;  /* rh[0] - DFC command*/
  154.             cnt++;
  155.     }
  156.  
  157.     p1 = (char *)t_seg;
  158.     p = p1 + PR_SIZE; /* pointer to RU in buffer */
  159.         p1 = &((*p_rcb).first_in);
  160.         if (t_seg -> link == NULL) {
  161.             dsc = 0;
  162.         }
  163.         else
  164.                 dsc = 1;
  165.         if (i == 0) {
  166.                buffmng('A', NULL, p1, p_rcb, i, dsc, type);
  167.         }
  168.         else
  169.              {
  170.              /* Set each logical record as a separate member */
  171.                while (i > 0) {
  172.             pr_ll = (union prll *)p;
  173.                     tp = pr_ll -> chs.s1;
  174.                     pr_ll -> chs.s1 = pr_ll -> chs.s2;
  175.                     pr_ll -> chs.s2 = tp; /* invert to compatibility with
  176.                                            * IBM mainframe. */
  177.                     ti = pr_ll -> len;    /* with prefix itself */
  178.                     if (ti > i) {
  179.                        ti = i;
  180.                        type = Data_INCOMPLETE;
  181.                     }
  182.                     else
  183.                        type = Data_COMPLETE;
  184.                     if ((tp1 = malloc(ti)) == NULL) {
  185.                        sense = 0x1008600b; /* RESOURCE_FAILURE_NO_RETRY */
  186.                        bldfmh7(p_rcb, sense);
  187.                        return (-1);
  188.                     }
  189.                     memcpy(tp1, p, ti);
  190.                     buffmng('A', tp1, p1, p_rcb, ti, dsc, type);
  191.                     i -= ti;
  192.                     p += ti;
  193.                }
  194.              }
  195.  
  196.     } while (t_seg -> link != NULL);
  197.     return (0);
  198. }
  199.